/**
 * 工具函数库
 * 包含单位转换、文本处理等辅助功能
 */

/**
 * 单位转换工具类
 */
class UnitConverter {
    /**
     * 中文字号到磅值的映射表
     */
    static CHINESE_FONT_SIZE_MAP = {
        '初号': 42,
        '小初号': 36,
        '一号': 26,
        '小一号': 24,
        '二号': 22,
        '小二号': 18,
        '三号': 16,
        '小三号': 15,
        '四号': 14,
        '小四号': 12,
        '五号': 10.5,
        '小五号': 9,
        '六号': 7.5,
        '小六号': 6.5,
        '七号': 5.5,
        '八号': 5
    };

    /**
     * 转换字体大小为磅值
     * @param {string} size - 字体大小字符串
     * @returns {number} 磅值
     */
    static convertFontSize(size) {
        if (!size) return 12;
        
        // 检查是否为中文字号
        if (this.CHINESE_FONT_SIZE_MAP[size]) {
            return this.CHINESE_FONT_SIZE_MAP[size];
        }
        
        // 提取数字和单位
        const match = size.match(/^(\d+(?:\.\d+)?)(pt|px|em)?$/i);
        if (match) {
            const value = parseFloat(match[1]);
            const unit = (match[2] || '').toLowerCase();
            
            switch (unit) {
                case 'px': return value * 0.75; // 近似转换
                case 'em': return value * 12; // 假设基础字体为12pt
                default: return value; // pt或无单位
            }
        }
        
        return 12; // 默认值
    }

    /**
     * 转换缩进值为磅值
     * @param {string} indent - 缩进字符串
     * @param {number} fontSize - 当前字体大小（磅值）
     * @returns {number} 磅值
     */
    static convertIndent(indent, fontSize = 12) {
        if (!indent) return 0;
        
        // 字符单位（中文字符）
        if (indent.includes('字符')) {
            const chars = parseFloat(indent.replace(/字符.*/, '')) || 0;
            // 1个中文字符约等于字体大小的磅值
            return chars * fontSize;
        }
        
        // 其他单位
        return this.convertLengthToPoints(indent);
    }

    /**
     * 转换长度单位为磅值
     * @param {string} length - 长度字符串
     * @returns {number} 磅值
     */
    static convertLengthToPoints(length) {
        if (!length) return 0;
        
        const match = length.match(/^(\d+(?:\.\d+)?)(pt|cm|mm|in|px)?$/i);
        if (match) {
            const value = parseFloat(match[1]);
            const unit = (match[2] || 'pt').toLowerCase();
            
            switch (unit) {
                case 'cm': return value * 28.35;
                case 'mm': return value * 2.835;
                case 'in': return value * 72;
                case 'px': return value * 0.75;
                default: return value; // pt
            }
        }
        
        return 0;
    }

    /**
     * 转换间距值为磅值
     * @param {string} spacing - 间距字符串
     * @param {number} fontSize - 当前字体大小（磅值）
     * @returns {number} 磅值
     */
    static convertSpacing(spacing, fontSize = 12) {
        if (!spacing) return 0;
        
        // 行单位
        if (spacing.includes('行')) {
            const lines = parseFloat(spacing.replace(/行.*/, '')) || 0;
            return lines * fontSize * 1.2; // 假设行高为字体大小的1.2倍
        }
        
        // 其他单位
        return this.convertLengthToPoints(spacing);
    }

    /**
     * 转换行距值
     * @param {string} lineSpacing - 行距字符串
     * @returns {number} 行距值（倍数或磅值）
     */
    static convertLineSpacing(lineSpacing) {
        if (!lineSpacing) return 1.15;
        
        // 倍数
        if (lineSpacing.includes('倍')) {
            const multiplier = parseFloat(lineSpacing.replace(/倍.*/, '')) || 1;
            return multiplier;
        }
        
        // 磅值（返回磅值，Office.js会自动处理）
        const points = this.convertLengthToPoints(lineSpacing);
        return points > 0 ? points : 1.15;
    }
}

/**
 * 文本处理工具类
 */
class TextProcessor {
    /**
     * 清理和标准化文本
     * @param {string} text - 原始文本
     * @returns {string} 清理后的文本
     */
    static cleanText(text) {
        if (!text) return '';
        
        return text
            .replace(/\r\n/g, '\n') // 统一换行符
            .replace(/\r/g, '\n')
            .replace(/\t/g, '    ') // 制表符转为空格
            .trim();
    }

    /**
     * 分割文本为行
     * @param {string} text - 文本
     * @returns {Array<string>} 行数组
     */
    static splitLines(text) {
        return this.cleanText(text).split('\n');
    }

    /**
     * 移除Markdown标记，获取纯文本
     * @param {string} markdown - Markdown文本
     * @returns {string} 纯文本
     */
    static stripMarkdown(markdown) {
        if (!markdown) return '';
        
        return markdown
            .replace(/^#+\s*/, '') // 移除标题标记
            .replace(/\*\*([^*]+)\*\*/g, '$1') // 移除加粗标记
            .replace(/\*([^*]+)\*/g, '$1') // 移除斜体标记
            .replace(/`([^`]+)`/g, '$1') // 移除行内代码标记
            .trim();
    }

    /**
     * 检测文本是否包含中文字符
     * @param {string} text - 文本
     * @returns {boolean} 是否包含中文
     */
    static containsChinese(text) {
        return /[\u4e00-\u9fa5]/.test(text);
    }

    /**
     * 计算文本的字符长度（中文字符算1个，英文字符算0.5个）
     * @param {string} text - 文本
     * @returns {number} 字符长度
     */
    static getCharacterLength(text) {
        if (!text) return 0;
        
        let length = 0;
        for (const char of text) {
            if (this.containsChinese(char)) {
                length += 1; // 中文字符
            } else {
                length += 0.5; // 英文字符
            }
        }
        return length;
    }
}

/**
 * 样式工具类
 */
class StyleUtils {
    /**
     * Word对齐方式映射
     */
    static ALIGNMENT_MAP = {
        '左对齐': 'left',
        '居中': 'centered',
        '右对齐': 'right',
        '两端对齐': 'justified',
        'left': 'left',
        'center': 'centered',
        'right': 'right',
        'justify': 'justified'
    };

    /**
     * 转换对齐方式
     * @param {string} alignment - 对齐方式字符串
     * @returns {string} Word对齐方式
     */
    static convertAlignment(alignment) {
        if (!alignment) return 'left';
        return this.ALIGNMENT_MAP[alignment] || 'left';
    }

    /**
     * 转换布尔值
     * @param {string} value - 字符串值
     * @returns {boolean} 布尔值
     */
    static convertBoolean(value) {
        if (!value) return false;
        
        const lowerValue = value.toLowerCase().trim();
        return lowerValue === '是' || 
               lowerValue === 'true' || 
               lowerValue === 'yes' || 
               lowerValue === '1';
    }

    /**
     * 生成样式名称（用于Word样式）
     * @param {string} styleType - 样式类型
     * @returns {string} 样式名称
     */
    static generateStyleName(styleType) {
        const prefix = 'MarkdownFormatter_';
        const timestamp = Date.now().toString().slice(-6);
        return `${prefix}${styleType}_${timestamp}`;
    }

    /**
     * 验证样式规则
     * @param {Object} rule - 样式规则对象
     * @returns {Object} 验证结果 {isValid: boolean, errors: Array<string>}
     */
    static validateStyleRule(rule) {
        const errors = [];
        
        // 检查字体大小
        if (rule['字体大小']) {
            const fontSize = UnitConverter.convertFontSize(rule['字体大小']);
            if (fontSize < 5 || fontSize > 72) {
                errors.push(`字体大小 "${rule['字体大小']}" 超出合理范围 (5-72pt)`);
            }
        }
        
        // 检查行距
        if (rule['行距']) {
            const lineSpacing = UnitConverter.convertLineSpacing(rule['行距']);
            if (lineSpacing < 0.5 || lineSpacing > 3) {
                errors.push(`行距 "${rule['行距']}" 超出合理范围 (0.5-3倍)`);
            }
        }
        
        // 检查对齐方式
        if (rule['对齐方式']) {
            const alignment = this.convertAlignment(rule['对齐方式']);
            if (!['left', 'centered', 'right', 'justified'].includes(alignment)) {
                errors.push(`不支持的对齐方式: "${rule['对齐方式']}"`);
            }
        }
        
        return {
            isValid: errors.length === 0,
            errors: errors
        };
    }
}

/**
 * 调试工具类
 */
class DebugUtils {
    /**
     * 是否启用调试模式
     */
    static DEBUG_MODE = false;

    /**
     * 启用/禁用调试模式
     * @param {boolean} enabled - 是否启用
     */
    static setDebugMode(enabled) {
        this.DEBUG_MODE = enabled;
    }

    /**
     * 调试日志
     * @param {string} message - 消息
     * @param {any} data - 数据
     */
    static log(message, data = null) {
        if (this.DEBUG_MODE) {
            console.log(`[Markdown Formatter] ${message}`, data);
        }
    }

    /**
     * 错误日志
     * @param {string} message - 消息
     * @param {Error} error - 错误对象
     */
    static error(message, error = null) {
        console.error(`[Markdown Formatter] ${message}`, error);
    }

    /**
     * 性能计时开始
     * @param {string} label - 计时标签
     */
    static timeStart(label) {
        if (this.DEBUG_MODE) {
            console.time(`[Markdown Formatter] ${label}`);
        }
    }

    /**
     * 性能计时结束
     * @param {string} label - 计时标签
     */
    static timeEnd(label) {
        if (this.DEBUG_MODE) {
            console.timeEnd(`[Markdown Formatter] ${label}`);
        }
    }
}

// 导出工具类（如果使用模块化）
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        UnitConverter,
        TextProcessor,
        StyleUtils,
        DebugUtils
    };
}
